import java.awt.image.BufferedImage;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class ImageRGB {
  private BufferedImage img;
  
  public ImageRGB(String f){
  // prérequis : f (ou f.bmp) est le nom d'un fichier bit-map
  // image RGB construite à partir du fichier de nom f
  // (ou f.bmp si le suffixe .bmp est absent de f)
	if(f.length()<4 || !f.substring(f.length()-4,f.length()).equals(".bmp")){f=f+".bmp";}
	try{
	  DataInputStream inBMP = new DataInputStream(new FileInputStream(new File(f)));
	  inBMP.skipBytes(18); // saute le début de l'entête
	  // largeur et hauteur de l'image
	  int largeur = litEntier32bits(inBMP); int  hauteur = litEntier32bits(inBMP);      
	  inBMP.skipBytes(28); // saute les données inutiles del'entête
	  // crée et remplit img
	  img = new BufferedImage(largeur, hauteur, BufferedImage.TYPE_INT_RGB);
	  int tailleBourrage = (4-((largeur*3) % 4))%4; // nombre d'octets de bourrage dans chaque ligne
	  // Lecture des pixels
		for(int y=hauteur-1; y>=0; y--){
		  for(int x=0; x<largeur; x++){img.setRGB(x, y, litPixel24bits(inBMP));}      
		  inBMP.skipBytes(tailleBourrage); // saute le bourrage
	   } 
	   inBMP.close();
	}
	catch(Exception e){ System.out.println("problème avec la lecture du fichier "+f);}
  }

  private ImageRGB (int largeur, int hauteur){
	  // image non définie de largeur x hauteur pixels
		img = new BufferedImage(largeur, hauteur, BufferedImage.TYPE_INT_RGB);
  }
  
  public static ImageRGB unie(int largeur, int hauteur, PixelRGB pix){
  // résultat : une image unie de largeur x hauteur pixels égaux à pix
	ImageRGB iRGB = new ImageRGB(largeur, hauteur);
        for(int i=0;i<hauteur; i++){
            for(int j=0; j<largeur; j++){
                iRGB.setPixelRGB(i, j, pix);	
            }
        }
	return iRGB;
  }
  
  public static ImageRGB blanche(int largeur, int hauteur){
  // résultat : une image blanche de largeur x hauteur pixels 	  
    return unie(largeur, hauteur, PixelRGB.blanc());
  }
  
  public static ImageRGB noire(int largeur, int hauteur){
  // résultat : une image noire de largeur x hauteur pixels 	  
	return unie(largeur, hauteur, PixelRGB.noir());
  }
  
  private static int litEntier32bits(DataInputStream in){
  // effet : lecture d'un entier sur 4 octets depuis in
  // résultat : l'entier lu
    byte[] b = new byte[4];
    int resul = 0;
    try{
      in.read(b);
      resul = b[0] & 0xFF;
      resul = resul + ((b[1]&0xFF) << 8);
      resul = resul + ((b[2]&0xFF) << 16);
      resul = resul + ((b[3]&0xFF) << 24);	
    }
    catch(Exception e){}
    return resul;
  }

   
  private static int litPixel24bits(DataInputStream in){
  // effet : lecture d'un pixel sur 3 octets depuis in
  // résultat : l'entier correspondant au pixel lue
    byte[] b = new byte[3];
    int result = 0;
    try{
      in.read(b);  		
      result = b[0] & 0xFF;
      result = result + ((b[1] & 0xFF) << 8);
      result = result + ((b[2] & 0xFF) << 16);
    }
    catch(Exception e){}
    return result;
  }


  public boolean enregistreBitMap(String f) {
  // effet : crée à partir de this un fichier bit-map de nom f
  // (ou f.bmp si le suffixe .bmp est absent de f)
  // résultat : indique si l'enregistrement s'est bien effectué
    if(f.length()<4 || !f.substring(f.length()-4,f.length()).equals(".bmp")){f=f+".bmp";}
    try{
      DataOutputStream outBMP = new DataOutputStream(new FileOutputStream(f));
      //écriture de l'entête du fichier
      outBMP.write(0x42); outBMP.write(0x4D); //Type
      int largeur = img.getWidth(); int hauteur = img.getHeight();
      int tailleBourrage =(4-((largeur*3) % 4))%4; // nombre d'octets de remplissage en fin de chaque ligne
      ecritEntier32bits(outBMP,hauteur*(largeur*3+tailleBourrage)+54); //Taille du fichier
      ecritEntier32bits(outBMP,0); //Réservé
      ecritEntier32bits(outBMP,54);ecritEntier32bits(outBMP,40);
      ecritEntier32bits(outBMP,largeur); //Largeur
      ecritEntier32bits(outBMP,hauteur); //Hauteur
      outBMP.write(1); outBMP.write(0); 
      outBMP.write(24); outBMP.write(0); //Nombre de bits par pixel
      ecritEntier32bits(outBMP,0); // pas de compression
      ecritEntier32bits(outBMP,hauteur*(largeur*3+tailleBourrage)); // taille de l'image en octets
      ecritEntier32bits(outBMP,2851); ecritEntier32bits(outBMP,2851); // résolution en largeur et hauteur
      ecritEntier32bits(outBMP,0); // nombre de couleurs = 2^24
      ecritEntier32bits(outBMP,0); // toutes les couleurs sont importantes
      //Ecriture du corps du fichier BMP
      for (int y=hauteur-1; y>=0; y--) {
      	//System.out.println(" l "+y);
        for (int x=0; x<largeur; x++) {            
            ecritPixel24bits(outBMP, img.getRGB(x,y));
        }
        //Bourrage
        for (int j=0; j<tailleBourrage; j++) {outBMP.write(0);}
      }
      //Fermeture du fichier
      outBMP.close();
      System.out.println("Enregistrement réussi!");
      return true;
    }
    catch(Exception e){System.out.println("ERREUR : "+e); return false;}
  }

  private static void ecritEntier32bits(DataOutputStream sortie, int n) {
  // effet : écrit n dans sortie sur 4 octets selon le format little indian
    try {
      sortie.write((n) & 0xFF);
      sortie.write((n>>8) & 0xFF);
      sortie.write((n>>16) & 0xFF);
      sortie.write((n>>24) & 0xFF);
    }
    catch (Exception e) {}
  }
   
  private static void ecritPixel24bits(DataOutputStream sortie, int p) {
  // effet : écrit le pixel correspondant à p dans sortie sur 3 octets
    try {
      sortie.write((p) & 0xFF);
      sortie.write((p>>8) & 0xFF);
      sortie.write((p>>16) & 0xFF);
    }
    catch (Exception e) {}
  }
  
  public int hauteur(){ // résultat : la hauteur de this
	  return img.getHeight();
  }
  
  public int largeur(){ // résultat : la largeur de this
	  return img.getWidth();
  }
  
  public PixelRGB getPixelRGB(int i, int j){
  // prérequis : 0<=i<this.hauteur() et 0<=j<this.largeur()
  // résultat : le pixel en position verticale i et horizontale j
	  int p=img.getRGB(j,i);
	  return new PixelRGB((p>>16)&0xFF,(p>>8)&0xFF,p&0xFF);
  }
  
  public void setPixelRGB(int i, int j, PixelRGB pix){
  // prérequis : 0<=i<this.hauteur() et 0<=j<this.largeur()
  // effet : remplace par pix le pixel de this position (i,j)
	  int p=pix.getB()+(pix.getG()<<8) + (pix.getR()<<16);
	  img.setRGB(j,i,p);
  }
  
  public int[] tabBin(int col,String s){
	  // remplit un tableau de taille 8 à partir d'une chaine binaire de taille <=8
	  int bin[]=new int[8]; // tableau contenant un octet
	  
	  for (int i=0;i<8;i++){ // initialisation du tableau
		  bin[i]=0;
	  }
	  int x=7;
	  for (int i=s.length()-1;i>=0;i--){ // remplissage du tableau		  
		  bin[x]=(int)s.charAt(i)-48;
		  x--;
	  }
	  return bin;
  }
  
  public int[] tabBin2(int col,String s){
	  // remplit un tableau de taille 8 à partir d'une chaine binaire de taille 8
	  int bin[]=new int[8]; // tableau contenant un octet
	  
	  for (int i=0;i<8;i++){ // initialisation du tableau
		  bin[i]=0;
	  }
	  
	  int x=0;
	  for (int i=0;i<8;i++){ // remplissage du tableau
		  if (x<s.length()) {
			  bin[i]=(int)s.charAt(x)-48;			 
			  x++;
		  }
	  }	  
	  return bin;
  }
  
  public int binToDec(int[] tab){
	  //action: retourne la valeur décimale d'un tableau binaire
	  int i=1*tab[7]+2*tab[6]+4*tab[5]+8*tab[4]+16*tab[3]+32*tab[2]+64*tab[1]+128*tab[0];
	  return i;
  }
  
  public int[] modifTab(int[] tab,int i, int j){
	  //action: modifie le tableau pour cacher un "morceau" du caractère
	  tab[6]=i;
	  tab[7]=j;
	  return tab;
  }
  
  public static String crypteTexte(String s, String mdp) {
	  // action: modifie le texte à cacher en fonction du mot de passe
	  String crypt="";
	  int j=0;
	  char c; // caractère issu de la chaine à crypter
	  char m; // caractère issu du mot de passe
	  int cr; // nombre ascii de la somme c+m
	  for (int i=0;i<s.length();i++) {
		  c=s.charAt(i);
		  if (j<mdp.length()) {
			  m=mdp.charAt(j);
			  j++;
		  }
		  else {
			  j=0;
			  m=mdp.charAt(j);
			  j++;
		  }
		  cr=m+c+mdp.length();
		  //System.out.println((int)m+"+"+(int)c+"="+cr);
		  if(cr>255) { // si cr>0, on lui attribut une valeur comprise dans l'ascii quand même
			  cr=cr-255;
			 //System.out.println("cr a dépassé 255!"+cr);
		  }
		  crypt=crypt+(char)cr;
		 // System.out.println(cr);
	  }
	  return crypt;
  }
  
  public static String deCrypteTexte(String s, String mdp) {
	  //action: décrypte le texte avant de l'afficher à l'utilisateur
	  String decrypt="";
	  int j=0;
	  char c; // caractère issu de la chaine à décrypter
	  char m; // caractère issu du mot de passe
	  int decr; // nombre ascii de la différence c-m
	  System.out.println(s);
	  for (int i=0;i<s.length();i++) {
		  c=s.charAt(i);
		  if (j<mdp.length()) {
			  m=mdp.charAt(j);
			  j++;
		  }
		  else {
			  j=0;
			  m=mdp.charAt(j);
			  j++;
		  }
		  decr=c-m-mdp.length();
		  //System.out.println((int)m+"-"+(int)c+"="+decr);
		  if(decr<0) { // si cr>0, on lui attribut une valeur comprise dans l'ascii quand même
			  decr=decr+255;
			  //System.out.println("cr é été inférieur à 0!  "+decr);
		  }
		  decrypt=decrypt+(char)decr;
		  //System.out.println(decr);
	  }
	  return decrypt;
  }
  
  public void cacheCar(char c, PixelRGB px1, PixelRGB px2,PixelRGB px3,PixelRGB px4,int i,int j){
	  //prérequis: 0<=i<this.hauteur() et 0<=j<this.largeur()
	  //fonction: cache un caractère dans 4 pixelsfon
	  
	  int tabc[]; //tableau binaire correspondant au code ascii du caractère c
	  int tab1[]; //tableaux binaires des nuances de bleu des pixels
	  int tab2[];
	  int tab3[];
	  int tab4[];
  
	  int ic= (int)c; //x prend la valeur ascii du charactère c
	  //System.out.println(ic);
	  String sx=Integer.toBinaryString(ic); //conversion en chaine de caractères binaires
	  /*System.out.println("Chaine binaire de c:");
	  System.out.println(sx);*/
	  tabc=tabBin(ic,sx);
	  
	  /*System.out.print("\n"+"Tableau binaire de c:"+"\n");	  
	  for (int i1=0;i1<8;i1++){
		  System.out.print(tabc[i1]);
	  }
	  System.out.println();*/
	  
	  int b1= px1.getB(); //prend l'intensité de bleu du pixel px1 
	  int b2= px2.getB(); //prend l'intensité de bleu du pixel px2 
	  int b3= px3.getB(); //prend l'intensité de bleu du pixel px3
	  int b4= px4.getB(); //prend l'intensité de bleu du pixel px3
	  
	  int g1= px1.getG(); //prend l'intensité de vert du pixel px1 
	  int g2= px2.getG(); //prend l'intensité de vert du pixel px2 
	  int g3= px3.getG(); //prend l'intensité de vert du pixel px3
	  int g4= px4.getG(); //prend l'intensité de vert du pixel px4
	  
	  int r1= px1.getR(); //prend l'intensité de rouge du pixel px1 
	  int r2= px2.getR(); //prend l'intensité de rouge du pixel px2 
	  int r3= px3.getR(); //prend l'intensité de rouge du pixel px3
	  int r4= px4.getR(); //prend l'intensité de rouge du pixel px3
	  
	  String s1=Integer.toBinaryString(b1); //conversion des int en chaines binaires
	  String s2=Integer.toBinaryString(b2);
	  String s3=Integer.toBinaryString(b3);
	  String s4=Integer.toBinaryString(b4);
	  
	  /*System.out.println("Chaines binaires des pixels capturés:");
	  System.out.println(s1);
	  System.out.println(s2);
	  System.out.println(s3);
	  System.out.println(s4);*/
	  
	  tab1=tabBin(b1,s1); //remplissage des tableaux avec les chaines binaires de chaque couleur du pixel
	  tab2=tabBin(b2,s2);
	  tab3=tabBin(b3,s3);
	  tab4=tabBin(b4,s4);
	  
	  tab1=modifTab(tab1,tabc[0],tabc[1]); //modification des chaines binaires pour cacher le caractère
	  tab2=modifTab(tab2,tabc[2],tabc[3]);
	  tab3=modifTab(tab3,tabc[4],tabc[5]);
	  tab4=modifTab(tab4,tabc[6],tabc[7]);
	  
	  /*System.out.println("Tableaux des pixels modifiés:");
	  System.out.print("1:  ");
	  for (int i2=0;i2<8;i2++){
		  System.out.print(tab1[i2]);
	  }
	  System.out.print("	2:  ");
	  for (int i2=0;i2<8;i2++){
		  System.out.print(tab2[i2]);
	  }
	  System.out.print("	3:  ");
	  for (int i2=0;i2<8;i2++){
		  System.out.print(tab3[i2]);
	  }
	  System.out.print("	4:  ");
	  for (int i2=0;i2<8;i2++){
		  System.out.print(tab4[i2]);
	  }
	  
	  System.out.println();*/
	  
	  PixelRGB p1=new PixelRGB(r1,g1,binToDec(tab1)); //création des nouveaux pixels
	  PixelRGB p2=new PixelRGB(r2,g2,binToDec(tab2));
	  PixelRGB p3=new PixelRGB(r3,g3,binToDec(tab3));
	  PixelRGB p4=new PixelRGB(r4,g4,binToDec(tab4));
	  
	  /*System.out.println("Pixels après modification:");
	  System.out.println(p1);
	  System.out.println(p2);
	  System.out.println(p3);
	  System.out.println(p4);*/
	  
	  this.setPixelRGB(i,j,p1); //insertion des pixels dans l'image
	  this.setPixelRGB(i,j+1,p2);
	  this.setPixelRGB(i,j+2,p3);
	  this.setPixelRGB(i,j+3,p4);
	  /*System.out.println("Caractère codé: "+c);
	  System.out.println("------------------------------------------------------------------------------------------------------");*/
  }
  
  public void cacheTexte(String message, String mdp){
	  //prérequis: texte pas trop long
	  //cache le message s dans l'image
	  int x=0;
	  int j;
	  String s=crypteTexte(message,mdp);
	  String taille=Integer.toString(s.length());
	  int[] tabtaille=new int[8]; //tableau la contenant
	  /*System.out.println("Chaine de caractère à cacher:");
	  System.out.println(s);
	  System.out.println("Taille de la chaine de caractère à cacher:");
	  System.out.println(taille);*/
	  
	  for (int i=0;i<8;i++) { // initialisation
		  tabtaille[i]=0;
	  }
	  
	  j=taille.length()-1;
	  for (int i=7;i>=0;i--){ // remplissage du tableau
		  if (j>=0) {
			  tabtaille[i]=taille.charAt(j)-48;
			  j--;
		  }		  
	  }	
	  
	  for (int i=0;i<8;i++) { // affichage
		  System.out.print(tabtaille[i]);
	  }
	  
	  /*System.out.println();
	  System.out.println("------------------------------------------------------------------------------------------------------");*/
	  
	  PixelRGB p1;
	  PixelRGB p2;
	  PixelRGB p3;
	  PixelRGB p4;
	  
	  p1=this.getPixelRGB(0,0); // entête pour savoir si l'image est cryptée ou pas par ce programme: "ok"
	  p2=this.getPixelRGB(0,1);
	  p3=this.getPixelRGB(0,2);
	  p4=this.getPixelRGB(0,3);
	  this.cacheCar('o',p1,p2,p3,p4,0,0);
	  
	  p1=this.getPixelRGB(0,4); 
	  p2=this.getPixelRGB(0,5);
	  p3=this.getPixelRGB(0,6);
	  p4=this.getPixelRGB(0,7);
	  this.cacheCar('k',p1,p2,p3,p4,0,4);
	  
	  j=8;
	  for (int i=0;i<8;i++) { // On cache la longueur de la chaine cachée pour éviter au programme de tourner pour rien
		  p1=this.getPixelRGB(0,j); 
		  p2=this.getPixelRGB(0,j+1);
		  p3=this.getPixelRGB(0,j+2);
		  p4=this.getPixelRGB(0,j+3);
		  this.cacheCar((char)tabtaille[i],p1,p2,p3,p4,0,j);
		  j=j+4;
	  }
	  
	  j=40;
	  for (int i=0;i<s.length();i++){
		  char c=s.charAt(i); //on prend un caractère dans la chaine de caractère à cacher
		  //System.out.println("						Pixel: "+i);
		  if (j+3<this.largeur() && x<=this.hauteur()){ //on est dans la ligne			  
			  p1=this.getPixelRGB(x,j); //on prend 4 pixels
			  p2=this.getPixelRGB(x,j+1);
			  p3=this.getPixelRGB(x,j+2);
			  p4=this.getPixelRGB(x,j+3);
			  this.cacheCar(c,p1,p2,p3,p4,x,j);
			  j=j+4;
		  }
		  else if(x<=this.hauteur()){ //on est en fin de ligne, retour à la ligne d'en dessous
			  j=0;
			  x++;
			  p1=this.getPixelRGB(x,j); //on prend 4 pixels
			  p2=this.getPixelRGB(x,j+1);
			  p3=this.getPixelRGB(x,j+2);
			  p4=this.getPixelRGB(x,j+3);
			  this.cacheCar(c,p1,p2,p3,p4,x,j);
			  j=j+4;
		  }	 
		  else {
			  //System.out.println("le message est trop grand par rapport à la taille de l'image");
			  System.exit(0);
		  }
	  }
  }
  
 
public char decodeCar(PixelRGB px1,PixelRGB px2,PixelRGB px3,PixelRGB px4){
	  int tabc[] = new int[8]; //tableau binaire correspondant au code ascii du caractère c
	  int tab1[]; //tableaux binaires des nuances de bleu des pixels
	  int tab2[];
	  int tab3[];
	  int tab4[];	
	  
	  char c; //caractère à trouver
	  
	  int b1= px1.getB(); //prend l'intensité de bleu du pixel px1 
	  int b2= px2.getB(); //prend l'intensité de bleu du pixel px2 
	  int b3= px3.getB(); //prend l'intensité de bleu du pixel px3
	  int b4= px4.getB(); //prend l'intensité de bleu du pixel px3
	  
	  /*System.out.println();
	  System.out.println("Pixels capturés:");
	  System.out.println(px1);
	  System.out.println(px2);
	  System.out.println(px3);
	  System.out.println(px4);*/
	  
	  String s1=Integer.toBinaryString(b1); //conversion des int en chaines binaires
	  String s2=Integer.toBinaryString(b2);
	  String s3=Integer.toBinaryString(b3);
	  String s4=Integer.toBinaryString(b4);
	  
	  /*System.out.println("Chaines binaires capturées:");
	  System.out.println(s1);
	  System.out.println(s2);
	  System.out.println(s3);
	  System.out.println(s4);*/
	  
	  tab1=tabBin2(b1,s1); //remplissage des tableaux avec les chaines binaires de chaque couleur du pixel
	  tab2=tabBin2(b2,s2);
	  tab3=tabBin2(b3,s3);
	  tab4=tabBin2(b4,s4);
	  
	  /*System.out.println("Tableaux binaires modifiés:");
	  System.out.print("1:  ");
	  for (int i=0;i<8;i++){
		  System.out.print(tab1[i]);
	  }
	  System.out.print("	2:  ");
	  for (int i=0;i<8;i++){
		  System.out.print(tab2[i]);
	  }
	  System.out.print("	3:  ");
	  for (int i=0;i<8;i++){
		  System.out.print(tab3[i]);
	  }
	  System.out.print("	4:  ");
	  for (int i=0;i<8;i++){
		  System.out.print(tab4[i]);
	  }
	  System.out.println();
	  System.out.println("------------------------------------------------------------------------------------------------------");*/
	  
	  tabc[0]=tab1[6]; //on remplit tabc avec les valeurs faibles qui contiennent le caractère
	  tabc[1]=tab1[7];
	  tabc[2]=tab2[6];
	  tabc[3]=tab2[7];
	  tabc[4]=tab3[6];
	  tabc[5]=tab3[7];
	  tabc[6]=tab4[6];
	  tabc[7]=tab4[7];

	  //System.out.println(tabc[0]);
	  
	  /*for (int i=0;i<8;i++){ //remplissage du tableau
		  System.out.print(tabc[i]);
	  }*/
	  
	  //System.out.println();
	  int ch=binToDec(tabc); //conversion du tableau binaire en int
	  //System.out.println("ch:  "+ch);
	  c=(char)ch; //conversion de l'int en char
	  return c;
  }
public boolean estCodee() {
	//retourne vrai si les deux premiers caractères décodés indiquent que l'image dissimule bien un message
	PixelRGB p1=this.getPixelRGB(0,0);
	PixelRGB p2=this.getPixelRGB(0,1);
	PixelRGB p3=this.getPixelRGB(0,2);
	PixelRGB p4=this.getPixelRGB(0,3);
	PixelRGB p5=this.getPixelRGB(0,4);
	PixelRGB p6=this.getPixelRGB(0,5);
	PixelRGB p7=this.getPixelRGB(0,6);
	PixelRGB p8=this.getPixelRGB(0,7);
	return(this.decodeCar(p1,p2,p3,p4)=='o' && this.decodeCar(p5,p6,p7,p8)=='k');
}

public long longChaine() {
	//décode la seconde partie de l'entête qui contient la longueur de la chaine codée
	int lon[]=new int[8];
	PixelRGB p1;
	PixelRGB p2;
	PixelRGB p3;
	PixelRGB p4;
	
	int y=8;
	for (int i=0;i<8;i++) {
		p1=this.getPixelRGB(0, y);
		p2=this.getPixelRGB(0, y+1);
		p3=this.getPixelRGB(0, y+2);
		p4=this.getPixelRGB(0, y+3);		
		lon[i]=(int)this.decodeCar(p1,p2,p3,p4);
		//System.out.println(this.decodeCar(p1,p2,p3,p4));
		y=y+4;
	}
	return lon[7]+10*lon[6]+100*lon[5]+1000*lon[4]+10000*lon[3]+100000*lon[2]+1000000*lon[1]+10000000*lon[0];
	
}

public String decodeTexte(String mdp) {
	String s="";
	//prérequis: texte pas trop long
	//cache le message s dans l'image
	int x=0;
	int y=40;
	PixelRGB p1=null;
	PixelRGB p2=null;
	PixelRGB p3=null;
	PixelRGB p4=null;
	this.longChaine();
	if (this.estCodee()){
		//System.out.println("L'image est bien codée!");
		for (int i=0;i<this.longChaine();i++){
			//System.out.println("						Caractère: "+(i+1));
			if (y+3<this.largeur() && x<this.hauteur()){ //on est dans la ligne
				p1=this.getPixelRGB(x,y); //on prend 4 pixels
				p2=this.getPixelRGB(x,y+1);
				p3=this.getPixelRGB(x,y+2);
				p4=this.getPixelRGB(x,y+3);
				//System.out.println("Caractère caché dans les pixels de "+x+" "+y+" à "+x+" "+(y+3));
			}
			else{//on est en fin de ligne, retour à la ligne d'en dessous
					y=0;
					x++;
					p1=this.getPixelRGB(x,y); //on prend 4 pixels
					p2=this.getPixelRGB(x,y+1);
					p3=this.getPixelRGB(x,y+2);
					p4=this.getPixelRGB(x,y+3);
					//System.out.println("Caractère caché dans les pixels "+x+" "+y+" et "+x+" "+(y+3));
				
			}
			char dec=this.decodeCar(p1,p2,p3,p4);
			s=s+dec;
			//System.out.println("Caractère décodé: "+dec);
			//System.out.println("------------------------------------------------------------------------------------------------------");
			y=y+4;
		}
		s=deCrypteTexte(s,mdp);
		return s;
	}
	else {
		//System.out.println(longChaine());
		return "Cette image ne cache pas de message!";
	}	
	
}	
}





